﻿using EGuayas.Web.Resources;
using EntGuayasSLA.BL;
using EntGuayasSLA.BL.Archivos.Pdf;
using EntGuayasSLA.BL.Listas;
using EntGuayasSLA.BL.Listas.Criterias;
using Ext.Net;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.IO;
using System.Linq;
using System.Text;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

namespace EGuayas.Web.Auditoria.Expedientes
{
    public partial class wucLoadDoc : ucWuc
    {
        #region Set-Session     
        protected String PageId
        {
            get
            {
             
                return ReadCustomConfigPage(this.pnlLoadDocumentos, this.ID);
            }

        }
        protected String ExpedienteId
        {
            get
            {
                return ReadCustomConfigExpediente(this.pnlLoadDocumentos, this.ID);
            }

        }
        /// <summary>
        /// Lista de documentos de requisitos segun fase de licenciamiento
        /// </summary>
        protected ItemLista RequisitosFase
        {
            get
            {
                if (Session[this.ID + "_ListaRequisitos1"] == null)
                {
                    Session[this.ID + "_ListaRequisitos1"] = new ItemLista();
                }
                return ((ItemLista)Session[this.ID + "_ListaRequisitos1"]);
            }
            set
            {
                Session[this.ID + "_ListaRequisitos1"] = value;
            }
        }
        protected string RequisitoOtroId
        {
            get
            {
                if (Session[this.ID + "_LoadDocReqOtro"] == null)
                {
                    Session[this.ID + "_LoadDocReqOtro"] = "";
                }
                return (Session[this.ID + "_LoadDocReqOtro"].ToString());
            }
            set
            {
                Session[this.ID + "_LoadDocReqOtro"] = value;
            }
        }
        protected String EstadoAuditoria
        {
            get
            {

                return ReadCustomConfigEstadoAuditoria(this.pnlLoadDocumentos, this.ID);
            }

        }
        #endregion Set-Session       
        protected void Page_Load(object sender, EventArgs e)
        {
         try
         {
                if (!X.IsAjaxRequest)
                {
                    if (HttpContext.Current.Session[PageId + Constantes.Expediente] != null)
                    {
                        DataBindRequisitos();
                        //VALIDAR HABILITAR BOTON <ENVIO>
                        if (GetSessionPage.GetSession(EstadoAuditoria) == Valores.Codigo_Estado_Fase_Inicial)
                        {
                            this.btnValidarDocumentos.Enable();
                        }
                        else
                        {
                            this.btnValidarDocumentos.Disable();
                            //MODO LECTURA

                            /*    
                            if (GetSessionPage.GetSession(EstadoFase) == Valores.Codigo_Estado_Fase_Finalizado)
                            {
                                this.gpDocumentosLoad.ColumnModel.Columns.RemoveAt(this.gpDocumentosLoad.ColumnModel.Columns.Count - 1);
                                this.gpDocumentosLoad.ColumnModel.Columns.RemoveAt(this.gpDocumentosLoad.ColumnModel.Columns.Count - 1);
                                this.gpDocumentosLoad.Reconfigure();
                                this.gpDocumentosLoad.Refresh();
                                       
                            }
                            */
                        }
                    }
                    else
                    {
                        btnForm.Disable();
                    }

                 }
            }
            catch (Exception ex)
            {
                RegistrarLog("wucLoadDoc.Page_Load" + ex);
            }
        }
        private void DataBindRequisitos()
        {
            try
            {
                //Obtener requisitos obligatorio
                ItemLista RequisitosFaseObliga = ItemLista.GetItemListaCodigo(Valores.Catalogo_Cod_DocExpediente, Valores.Codigo_CHAR_Si);
                stoReqOblig.DataSource = RequisitosFaseObliga;
                stoReqOblig.DataBind();

                ItemLista RequisitosFase = ItemLista.GetItemListaCodigo(Valores.Catalogo_Cod_DocExpediente, Valores.Codigo_CHAR_Si);
                //Obtener <ID> requisitos <otros> 
                ItemInfo infoItem = RequisitosFase.FirstOrDefault(r => r.Nombre == Valores.Nombre_DocFase);
                if (infoItem != null)
                {
                    RequisitoOtroId = infoItem.Id.ToString();
                }
                else
                {
                    RequisitoOtroId = "";
                }
                //Asignar al store para nuevas versiones          
                stoTipoVersion.DataSource = RequisitosFase;
                stoTipoVersion.DataBind();
                //Quitar de lixbox item subidos 
                ItemLista itemsLoadCbx = RequisitosFase.Clone();
                //Obtener los archivos subidos actualmente
                ArchivoGlobalCriteria filter = ArchivoGlobalCriteria.NewArchivoGlobalCriteria();
                filter.ExpedienteId = GetSessionPage.ExpedienteId(PageId);             
                filter.Tabla = Valores.Modulo_Archivo_Expediente;
                ArchivoLista itemLoad = ArchivoLista.GetArchivoLista(filter);
               
                foreach (ArchivoInfo seek in itemLoad)
                {

                    ItemInfo item = itemsLoadCbx.FirstOrDefault(r => r.Id.ToString() == seek.TipoDocumento);
                    if (item != null && item.Id.ToString() != RequisitoOtroId)
                    {
                        itemsLoadCbx.Remove(item);
                    }
                }
                //
                stoTipo.DataSource = itemsLoadCbx;
                stoTipo.DataBind();
                
            }
            catch (Exception ex)
            {
                RegistrarLog("wucLoadDoc.DataBindRequisitos" + ex);
            }

        }
        public void WucInit()
        {
            try
            {

                if (HttpContext.Current.Session[PageId + Constantes.Expediente] != null)
                {

                    DataBindRequisitos();
                    btnForm.Enable();
                }
            }
            catch (Exception ex)
            {
                RegistrarLog("wucLoadDoc.WucInit" + ex);
            }

        }
        /// <summary>
        /// Datos de archivos de promotor
        /// </summary>
        /// <returns></returns>
        [DirectMethod(IDAlias = "WucLoadPromoDoc")]
        public ArchivoLista BindData()
        {
            try
            {
                if (HttpContext.Current.Session[PageId + Constantes.Expediente] != null)
                {
                    ArchivoGlobalCriteria filter = ArchivoGlobalCriteria.NewArchivoGlobalCriteria();
                    filter.ExpedienteId = GetSessionPage.ExpedienteId(PageId);
                    filter.Tabla = Valores.Modulo_Archivo_Expediente;
                    return ArchivoLista.GetArchivoLista(filter);
                }
                else
                {
                    return null;
                }
                
            }
            catch (Exception ex)
            {
                RegistrarLog("wucLoadDoc.BindData" + ex);
            }
            return null;
        }
        #region Expander Grid
       
        #endregion Expander Grid

        /// <summary>
        /// Subir archivos de promotor
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void UploadClick(object sender, DirectEventArgs e)
        {
            try
            {
                FileUploadField myCtlFileUp = (FileUploadField)this.FindControl("FileUploadDocUp");
                if (myCtlFileUp.HasFile)
                {
                    Boolean IfNewVer = Convert.ToBoolean(e.ExtraParams["hddnDocIfVer"]);
                 
                    int version = 0;
                    string fileExt = myCtlFileUp.PostedFile.FileName.Substring(myCtlFileUp.PostedFile.FileName.LastIndexOf('.') + 1);
                    string ruta = "";
                    string fileName = "";
                    string fileNameTmp = "";

                    Int32.TryParse(e.ExtraParams["hddnDocUpVers"], out version);
                    this.GetNameFile(myCtlFileUp, fileExt, ref ruta, ref fileName, ref fileNameTmp);

                    //TODO:Generar User id para descriptar y encriptar                
                    //Guid guid = Guid.NewGuid();

                    byte[] USER = Encoding.UTF8.GetBytes(ConfigurationManager.AppSettings.Get("UserPdf"));
                    byte[] OWNER = Encoding.UTF8.GetBytes(ConfigurationManager.AppSettings.Get("PwdPdf"));

                    if (fileExt.ToLower() == "pdf")
                    {
                        myCtlFileUp.PostedFile.SaveAs(fileNameTmp);
                        Pdf.EncryptFilePdf(fileNameTmp, fileName, USER, OWNER);
                        File.Delete(fileNameTmp);
                    }
                    else
                    {
                        myCtlFileUp.PostedFile.SaveAs(fileName);
                    }
                    string tpl = Mensajes.MensajeArchivoCorrecto;

                    Archivo objArch = Archivo.NewEditableRoot(Valores.Modulo_Archivo_Expediente);
                    objArch.Id = System.Guid.NewGuid();
                    //Nuevas versiones datos correguidos
                    objArch.SubirNuevo = "C";
                    if (version == 1)
                    {
                        objArch.SubirNuevo = "N";
                        objArch.Referencia = objArch.Id.ToString();
                        //tipo de documento en nuevas versionas check
                        objArch.TipoDocumento = e.ExtraParams["cbxTipo"];
                    }
                    else
                    {
                        Archivo objArchAnterior = null;
                        if (version > 2)
                        {
                            objArch.Referencia = e.ExtraParams["hddnDocUpRef"];
                            objArchAnterior = Archivo.GetEditableRoot(Guid.Parse(objArch.Referencia), Valores.Modulo_Archivo_Expediente);
                            objArch.TipoDocumento = objArchAnterior.TipoDocumento;
                        }
                        else
                        {
                            if (version == 2)
                            {
                               
                                objArch.Referencia = e.ExtraParams["hddnDocUpId"];
                                objArchAnterior = Archivo.GetEditableRoot(Guid.Parse(objArch.Referencia), Valores.Modulo_Archivo_Expediente);
                                if (objArchAnterior.Referencia == "")
                                {
                                   objArchAnterior.Referencia = objArchAnterior.Id.ToString();
                                   objArchAnterior.Save(); 
                                }
                                objArch.TipoDocumento = objArchAnterior.TipoDocumento;
                            }
                        }
                    }
                   
                    objArch.Nombre = e.ExtraParams["txtNombre"];
                    objArch.Descripcion = e.ExtraParams["txtDesp"];
                    objArch.FechaCreacion = DateTime.Now;
                    objArch.RequiereFirmar = Valores.Codigo_CHAR_No;
                    objArch.Firmado = Valores.Codigo_CHAR_No;
                   

                    objArch.Version = version;
                    objArch.RequiereFirmar = Valores.Codigo_CHAR_No;

                    objArch.PersonaId = GetSessionUsuario.PersonaId;
                    objArch.ExpedienteId = GetSessionPage.ExpedienteId(PageId);
                    objArch.Ruta = ruta;

                    objArch.Save();
                                        

                    //cbxTipo.GetStore().JsonData.Length;
                    //Guardar id archivos temporalmente recien creados
                    ExtNet.Js.Call("wucJsLoadDoc.AddIdsNew", objArch.Id.ToString(), objArch.Version.ToString());
                    gpDocumentosLoad.GetStore().Reload();
              
                    X.Msg.Show(new MessageBoxConfig
                    {
                        Buttons = MessageBox.Button.OK,
                        Icon = MessageBox.Icon.INFO,
                        Title = Titulos.TituloAviso,
                        Message = string.Format(tpl, myCtlFileUp.PostedFile.FileName)
                    });
                    winDocumento.Hide();
                    //Validacion de tipo de documento, eliminar del store item seleccionado.
                    if (RequisitoOtroId != objArch.TipoDocumento)
                    {

                        ModelProxy recordRequisito = cbxTipo.GetStore().Find("Id", objArch.TipoDocumento);
                        if (recordRequisito != null)
                        {
                            //Remover un item no definido
                            cbxTipo.GetStore().Remove(recordRequisito);
                        }

                    }
                }
                else
                {
                    winDocumento.Hide();
                    X.Msg.Show(new MessageBoxConfig
                    {
                        Buttons = MessageBox.Button.OK,
                        Icon = MessageBox.Icon.ERROR,
                        Title = Titulos.TituloAviso,
                        Message = Mensajes.MensajeArchivoIncorrecto
                    });

                }
               
            }
            catch (Exception ex)
            {
                winDocumento.Hide();
                RegistrarLog("wucLoadDoc.UploadClick" + ex);
                X.Msg.Show(new MessageBoxConfig
                {
                    Buttons = MessageBox.Button.OK,
                    Icon = MessageBox.Icon.ERROR,
                    Title = Titulos.TituloAviso,
                    Message = Mensajes.MensajeArchivoIncorrecto
                });
            }
        }
        /// <summary>
        /// Agregar Estado de Fase de licenciamiento
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void ValidarClick(object sender, DirectEventArgs e)
        {
            try
            {
                //Segun estado de fase Valores.Codigo_Estado_Fase_Inicial
                if (GetSessionPage.GetSession(EstadoAuditoria) == Valores.Codigo_Estado_Fase_Inicial)
                {
                    //Agregar item tabla recepcion de procesos
                    RecepcionProceso objRecep = RecepcionProceso.NewEditableRoot();
                    objRecep.Id = System.Guid.NewGuid();
                    objRecep.ExpedienteId = GetSessionPage.GetSession(ExpedienteId);
                    objRecep.CodigoFase = Constantes.LFaseExpAud;
                    objRecep.Tabla = Valores.Modulo_Archivo_Expediente;
                    objRecep.Jefatura = Constantes.Auditoria;
                    objRecep.Save();
                    //
                    ExpedienteAuditoria objExpAud = ExpedienteAuditoria.GetEditableRoot(objRecep.ExpedienteId);
                    objExpAud.Estado = Valores.Codigo_Estado_Aud_Proceso;
                    objExpAud.Save();
                    X.Msg.Show(new MessageBoxConfig() { Message = Mensajes.MensajeDocumentoEnvia, Title = Titulos.TituloAviso,
                                                        Buttons = MessageBox.Button.OK,
                                                        Icon = MessageBox.Icon.INFO,
                                                        Handler = "wucJsLoadDoc.ClearIdsNew()"
                    
                    });
                    this.btnValidarDocumentos.Disable();
                    //No vizualizar opciones eliminar en caso de validar
                    RemoveEndColumnGridGlobal(2, this.gpDocumentosLoad);
                }
            }
            catch (Exception ex)
            {
                RegistrarLog("wucLoadDoc.ValidarClick" + ex);
            }

        }
        /// <summary>
        /// Eliminar archivos de promotor
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>     
        protected void btnDocUpEliminar_Click(object sender, DirectEventArgs e)
        {
            try
            {
                var id = Guid.Parse(e.ExtraParams["hddArchDelId"]);
                Archivo objArch = Archivo.GetEditableRoot(id, Valores.Modulo_Archivo_Expediente);

                DeleteFile(objArch.Ruta);

                //var dataFile = ArchivoLista.GetArchivoLista(id);
                //foreach (var item in dataFile)
                //    DeleteFile(item.Ruta);

                objArch.Delete();
                objArch.Save();

                gpDocumentosLoad.GetStore().Reload();
                
               
                //Diferente de item otro, quitar de la lista de tipo de documentos
                if (RequisitoOtroId != objArch.TipoDocumento)
                {
                    Guid idTipoDocumento = Guid.Parse(objArch.TipoDocumento);
                    var itemAdd = RequisitosFase.FirstOrDefault(r => r.Id == idTipoDocumento);
                    if (itemAdd != null)
                    {
                        cbxTipo.GetStore().Add(new
                        {
                            Id = itemAdd.Id,
                            Nombre = itemAdd.Nombre,
                            Opcion = itemAdd.Opcion
                        });

                    }
                }
            }
            catch (Exception ex)
            {
                RegistrarLog("wucLoadDoc.btnDocUpEliminar_Click" + ex);
            }

        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="file"></param>
        private void DeleteFile(string file)
        {
           try
           {
            var path = Server.MapPath(file);
            if (System.IO.File.Exists(path))
                File.Delete(path);
           }
           catch (Exception ex)
           {
               RegistrarLog("wucLoadDoc.DeleteFile" + ex);
           }
        }
      
    }
}